package mnc.game.tifo;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Point;
import android.location.Location;
import android.media.AudioManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.preference.PreferenceManager;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;
import android.view.Display;
import android.view.LayoutInflater;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.FrameLayout;
import bayaba.engine.lib.GameInfo;

import com.pushbots.push.PBGenerateCustomNotification;
import com.pushbots.push.Pushbots;
import com.skplanet.dev.guide.helper.ConverterFactory;
import com.skplanet.dev.guide.helper.ParamsBuilder;
import com.skplanet.dev.guide.pdu.Response;
import com.skplanet.dev.guide.pdu.VerifyReceipt;
import com.skplanet.dodo.IapPlugin;
import com.skplanet.dodo.IapResponse;
import com.skt.gamecenter.GameCenter;
import com.skt.gamecenter.UpgradeGameCenterReceiver;
import com.skt.gamecenter.api.GCAPIManager;
import com.skt.gamecenter.dataset.CurrentUser;
import com.skt.gamecenter.dataset.ResponseValueData;
import com.skt.gamecenter.dataset.ResponseValueDataList;
import com.skt.gamecenter.exception.ErrorCode;
import com.skt.gamecenter.exception.IllegalArgumentException;
import com.skt.gamecenter.io.FileManager;
import com.skt.gamecenter.net.ClientReceiver;
import com.skt.gamecenter.net.Packet;
import com.skt.gamecenter.net.PacketField;

public class Tifo extends Activity implements ClientReceiver {
	private final String LOG_TAG = "Tifo";

	private GLView play;
	private GameMain sImg;
	public GameInfo gInfo;
	private View ad;
	private Context context;
	private Bitmap myProfileBm; // 친구 대표 이미지
	public Bitmap noticeBm = null;

	private DBTifoData mDBTifoData;
	private ComPenData mComPenData;

	ArrayList<HashMap<String, String>> mTifoList;
	String effect_sound = "Y";
	String back_sound = "Y";
	private String FRIEND_RANKING = "1";
	private String FRIEND_INVIT = "2";
	private String NOTICE_IMG = "3";
	loadImageAsync mTaskInfo;

	boolean isWifiConn;
	boolean isMobileConn;
	boolean bAuthTstore = false;

	/**
	 * T store 회원 아님
	 * */
	final static public int STATUS_NO_MEMBER = 0;

	/**
	 * T store 회원이지만 연동 안된 상태
	 * */
	final static public int STATUS_DISABLE_CONNECTION = 1;

	final static public int REQUEST_TYPE_ENABLE_CONNECTION = 0;
	final static public int REQUEST_TYPE_DISABLE_CONNECTION = 1;

	public int APPLY_STATUS = 9;

	/**
	 * 게임센터 업그레이드 리시버
	 * */
	public UpgradeGameCenterReceiver mGameCenterDoingUpgradeReceiver = null;

	/**
	 * 서버 설정을 위한 디파인
	 * */
 	 private static int serverId = GameCenter.GAMECENTER_REAL;
//	 private static int serverId = GameCenter.GAMECENTER_DEV;
	/**
	 * 게임 아이드 설정을 위한 디파인
	 * */
	public static String GCID = "GC00000639";

	public static String LEADER_BOARD_ID = "TIFOMNC3334";
	/**
	 * 게임센터 API 사용을 위한 객체
`	 * */
	private GCAPIManager mGCAPIManager = null;

	/**
	 * 친구에게 게임 메세지를 보내면 하트점수를 10를 준다
	 */
	private int FRIEND_GAME_SEND_COM_PEN = 10;

	/**
	 * 친구를 게임에 초대하면 하트점수 30를 준다
	 */
	private int FRIEND_INVIT_SEND_COM_PEN = 30;
	/**
	 * 사용자 정보
	 * */
	private CurrentUser mUserData = null;

	public ArrayList<HashMap<String, String>> mFriendRanking = new ArrayList<HashMap<String, String>>();
	public ArrayList<Bitmap> mFriendRanking_img = new ArrayList<Bitmap>();

	public ArrayList<HashMap<String, String>> mFriendInVit = new ArrayList<HashMap<String, String>>();
	public ArrayList<Bitmap> mFriendInVit_img = new ArrayList<Bitmap>();
	public String mFriendRanking_Btn[];
	public String mFriendInVit_Btn[];
	/**
	 * 대푱 이미지 다운로드를 위한 객체
	 * */
	private FileManager mFileManager = null;

	private IapPlugin mPlugin;
	private String AID = "OA00651516";
	private String mRequestId;

	public String PID_1 = "0910018456"; // 게임시간 1분 연장 아이템
	public String PID_2 = "0910018457"; // 게임시간 2분 연장 아이템
	public String PID_3 = "0910018458"; // 게임시간 3분 연장 아이템
	public String PID_4 = "0910018459"; // 게임시간 4분 연장 아이템
	public String PID_5 = "0910018460"; // 게임시간 5분 연장 아이템
	public String PID_6 = "0910018461"; // 게임시간 6분 연장 아이템

	private String dev_pluin = "development";
	private String real_pluin = "release";
	String DEV_SERVER_URL = "https://iapdev.tstore.co.kr/digitalsignconfirm.iap";
	String REAL_SERVER_URL = "https://iap.tstore.co.kr/digitalsignconfirm.iap";

	private String SERVER_WEB = "http://115.68.5.144:8080/tifo/";
	private String SERVER_URL = SERVER_WEB + "tifoNet.jsp";

	// //////////////// PUSH 서버 //////////////////////////
	private String SENDER_ID = "772098541670";
//	private String SENDER_ID = "772098541676";
	private String PUSHBOTS_APPLICATION_ID = "52f4ee4b1d0ab12a2a8b45ac";
	// ///////////////////////////////////////////////////

	private int bas_tifoCount = 5;
	private String curVersion = "";
	Handler handler = new Handler();
	AsyncInfo mAsynInfo;

	// MyHandler handler;
	private SharedPreferences defaultSharedPref;

	static boolean active = false;
	
	static boolean push = false;

	@Override
	public void onStart() {
		super.onStart();
		active = true;
	}

	@Override
	public void onStop() {
		super.onStop();
		active = false;
	}

	public static boolean isActive() {
		return active;
	}


	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		Pushbots.init(this, SENDER_ID, PUSHBOTS_APPLICATION_ID);


		getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
				WindowManager.LayoutParams.FLAG_FULLSCREEN);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setVolumeControlStream(AudioManager.STREAM_MUSIC);

		mComPenData = new ComPenData(this);

		/**
		 * 게임센터 Lib 초기화
		 * */
		GameCenter.initialize(this, GCID, serverId);

		/**
		 * 게임센터 API 객체 생성
		 * */
		mGCAPIManager = new GCAPIManager();

		/**
		 * 파일 매니져 객체 생성
		 * */
//		mFileManager = new FileManager();

		context = this.context;

		mDBTifoData = new DBTifoData(this);

		/**
		 * 인증 요청
		 **/
		// requestTstoreAuth();

		curVersion = getCurrentVersion();

		// / 결재 Plugin
		mPlugin = IapPlugin.getPlugin(this, real_pluin);

		defaultSharedPref = PreferenceManager.getDefaultSharedPreferences(this);



		mPhoneStateListener phoneListener = new mPhoneStateListener();
		TelephonyManager telephonyManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
		telephonyManager.listen(phoneListener,
				PhoneStateListener.LISTEN_CALL_STATE);
		Pushbots.getInstance().setMsgReceiver(customPushReceiver.class);
	

		invokeGamePage();
	}

	private String getCurrentVersion() {
		try {
			PackageInfo pi = this.getPackageManager().getPackageInfo(
					this.getPackageName(), 0);
			return pi.versionName;
		} catch (NameNotFoundException e) {
			return "";
		}
	}

	public void setContext(Context context) {

	}

	@Override
	public void onBackPressed() {
		if (sImg.GameMode == 5) {
			sImg.pointNum = sImg.pre_pointNum;
			sImg.GameMode = 4;
	
		} else if (sImg.GameMode == 4) {
			sImg.GameMode = 3;
		} else if (sImg.GameMode == 3) {
			sImg.GameMode = 91;
	
		} else if (sImg.GameMode == 2) {
			System.exit(0);
	
		} else if (sImg.GameMode == 91 || sImg.GameMode == 90) {
			sImg.GameMode = 99;
	
		} else if (sImg.GameMode == 2) {
			sImg.GameMode = 99;
		}
	}

	/**
	 * 공지사항 자세히 보기
	 */
	public void goUrl() {
		Intent intent1 = new Intent(this, WebViewActivity.class);
		intent1.putExtra("URL", SERVER_WEB + "notice.html");
		startActivity(intent1);
	}

	/**
	 * 동의내용 보기
	 */
	public void goLaw() {
		Intent intent1 = new Intent(this, WebViewActivity.class);
		intent1.putExtra("URL", SERVER_WEB + "apply.html");
		startActivity(intent1);
	}

	/**
	 * 환경설정
	 */
	public void getSettingData(Context context) {
		mTifoList = mDBTifoData.getDataList(context);
		if (mTifoList != null) {
			if (mTifoList.size() > 0) {
				effect_sound = mTifoList.get(0).get("effect_sound");
				back_sound = mTifoList.get(0).get("back_sound");
			} else {
				effect_sound = "Y";
				back_sound = "Y";
				setSettingData(context, System.currentTimeMillis() + "", "Y",
						"Y");
			}
		} else {
			effect_sound = "Y";
			back_sound = "Y";
			setSettingData(context, System.currentTimeMillis() + "", "Y", "Y");
		}

		String preDate = Util.getDateNoFormat(Util.getPrevDate(Util
				.getCurrentDate()));
		String res1 = mComPenData.getPreData(context, preDate);
	}

	public void setSettingData(Context context, String time,
			String effect_sound, String back_sound) {
		try {
			if (mTifoList != null) {
				if (mTifoList.size() > 0) {
					mDBTifoData.prcs(context, "U", time, effect_sound,
							back_sound);
				} else {
					mDBTifoData.prcs(context, "I", time, effect_sound,
							back_sound);
				}
			} else {
				mDBTifoData.prcs(context, "I", time, effect_sound, back_sound);
			}
			mTifoList = mDBTifoData.getDataList(context);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public Bitmap getBitmapFromURL(String src) {
		try {
			Log.e("src", src);
			URL url = new URL(src);
			HttpURLConnection connection = (HttpURLConnection) url
					.openConnection();
			connection.setDoInput(true);
			connection.connect();
			InputStream input = connection.getInputStream();
			Bitmap myBitmap = BitmapFactory.decodeStream(input);
			Log.e("Bitmap", "returned");
			return myBitmap;
		} catch (IOException e) {
			e.printStackTrace();
			Log.e("Exception", e.getMessage());
			return null;
		}
	}

	@Override
	protected void onDestroy() {
		Log.d(LOG_TAG, "onDestroy()");

		super.onDestroy();
		if (sImg != null)
			sImg.Back_Music.stop();

		/**
		 * 게임센터 API 객체 초기화
		 * */
		mGCAPIManager = null;
		mPlugin.exit();

	}

	@Override
	protected void onResume() {
		Log.d(LOG_TAG, "onResume()");
		super.onResume();

		if (APPLY_STATUS == STATUS_NO_MEMBER) {
			bAuthTstore = true;
			/**
			 * 인증 요청
			 **/
			requestReTstoreAuth();
		}
	}

	/**
	 * 게임센터 업그레이드 리시버 등록( 파라미터는 각 게임의 GCID )
	 * */
	public void upgradeGameCenter() {
		mGameCenterDoingUpgradeReceiver = new UpgradeGameCenterReceiver(this,
				GCID);
		if (mGameCenterDoingUpgradeReceiver != null) {
			mGameCenterDoingUpgradeReceiver.registerReceiver();
		}
	}

	/*
	 * T store 인증 요청 *
	 */
	public void requestTstoreAuth() {
		Log.d(LOG_TAG, "requestTstoreAuth()");

		try {
			mGCAPIManager.authTstore(Tifo.this);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();

			/**
			 * MDN 없는 경우 팝업 처리
			 */
			// AlertDialog dialog = new AlertDialog.Builder(Tifo.this)
			// .setTitle("안내")
			// .setMessage("고객님의 이용기기는 T store Game Center 이용 및 T store 회원가입이 불가능하여 게스트로 게임 실행합니다.")
			// .setPositiveButton("확인", mNoMDNListener)
			// .create();
			// dialog.show();
		}
	}

	/**
	 * MDN 없을 경우 처리 리스트
	 * */
	private DialogInterface.OnClickListener mNoMDNListener = new DialogInterface.OnClickListener() {
		@Override
		public void onClick(DialogInterface dialog, int which) {

			/**
			 * MDN이 없을 경우 게임 화면으로 이동
			 * */
			// invokeGamePage();
		}
	};

	/**
	 * 게임센터 API 요청 결과 처리
	 * */
	@Override
	public boolean onResponseData(int pkIndex, String resultCode,
			String resultMsg, ResponseValueData resp) {

		Log.d(LOG_TAG, "onResponseData()");

		/**
		 * T store 인증 결과 처리
		 * */
		if (pkIndex == Packet.IF_authTstore) {
			/**
			 * 사용자 정보
			 * */
			mUserData = GameCenter.getCurrentUser();
			/**
			 * 인증 성공 -> 게임 화면으로 이동
			 * */
			if (resultCode.equals(ErrorCode.SUCCESS_CODE) == true) { // 인증 성공
			// invokeGamePage(9);
				if (bAuthTstore == false) {
					sucessLogin();
				} else {
					reLogin();
				}
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(Tifo.this, "T store 인증 성공");
			}
			/**
			 * 인증 실패 ( T store 가입되어 있지만 최초 로그인 안 한 상태 -> 로그인 화면으로 이동 ) ( T store
			 * 가입되어 있지만 로그아웃 상태 -> 로그인 화면으로 이동 )
			 * */
			else if (resultCode
					.equals(ErrorCode.ERR_SERVER_AUTH_FAIL_NEED_FIRST_LOGIN_CODE) == true // 최초로그인
																							// 안
																							// 한
																							// 상태
					|| resultCode
							.equals(ErrorCode.ERR_SERVER_AUTH_FAIL_LOGOUT_CODE) == true) { // 로그아웃
																							// 상태
				invokeLoginPage(STATUS_DISABLE_CONNECTION);
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(Tifo.this,"T store 인증 성공 & 게임센터 연동 필요");
			}
			/**
			 * 인증 실패( T store 회원 아님 -> 로그인 화면으로 이동)
			 * */
			else if (resultCode
					.equals(ErrorCode.ERR_SERVER_AUTH_FAIL_NO_TSTORE_MEMBER_CODE) == true) {
				invokeLoginPage(STATUS_NO_MEMBER);
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(Tifo.this,"T store 회원 아님");
			} else { // 그 이외의 에러

				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(Tifo.this,"T store 인증 실패" + "(" + resultCode
				// + "," + resultMsg + ")");
				sImg.message = "T store 인증 실패" + "(" + resultCode + ","
						+ resultMsg + ")";
				sImg.GameMode = 98;
				sImg.endJob = 99;
			}
		}
		/**
		 * 게임센터 연동 설정 결과 처리
		 * */
		if (pkIndex == Packet.IF_enableGameCenterConnection) {
			/**
			 * 성공
			 * */
			if (resultCode.equals(ErrorCode.SUCCESS_CODE) == true) {
				/**
				 * 게임센터 연동 설정 요청 성공 -> 재인증 요청
				 * */
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this, "게임센터 연동 설정 성공");
				requestReTstoreAuth();
			}
			/**
			 * 실패
			 * */
			else {
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this, "게임센터 연동 설정 실패"+ "(" + resultCode +
				// "," + resultMsg + ")");
				sImg.message = "게임센터 연동 설정 실패" + "(" + resultCode + ","
						+ resultMsg + ")";
				sImg.endJob = 99;
				sImg.GameMode = 98;
			}
		}

		/**
		 * 폰북 친구 랭킹 리스트 조회 결과 처리
		 * */
		if (pkIndex == Packet.IF_getPhonebookFriendRankList) {
			/**
			 * 성공
			 * */
			if (resp != null
					&& resultCode.equals(ErrorCode.SUCCESS_CODE) == true) { // TODO
																			// 조건
																			// 추가
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this,"폰북 친구 랭킹 리스트 조회 성공");

				/**
				 * 전체 랭킹 수 정보 가져오기
				 * */
				int totalCnt = resp
						.getDataListSize(PacketField.IF_F_RES_LIST_FRIEND);

				if (totalCnt > 0) {
					if (mFriendRanking != null) {
						mFriendRanking.clear();
						mFriendRanking_img.clear();
					}

					/**
					 * 각 랭킹 정보 별 항목 설정
					 * */
					for (int i = 0; i < totalCnt; i++) {
						/**
						 * 1개 랭킹 정보 가져오기
						 * */
						ResponseValueDataList data = resp.getListData(i,
								PacketField.IF_F_RES_LIST_FRIEND);

						/**
						 * 랭킹 정보 설정 하기
						 * */
						mFriendRanking.add(getFriendRanking(data));
					}
					String date = Util.getDateNoFormat(Util.getCurrentDate());
					ArrayList<String> x = null;
					try {
						x = mComPenData.getDataList(sImg.MainContext, date);
					} catch (Exception e) {
						System.out.println(e);
					}
					mFriendRanking_Btn = new String[mFriendRanking.size()];
					for (int i = 0; i < mFriendRanking.size(); i++) {
						if (mFriendRanking.get(i).get("mdn")
								.equals(mUserData.mdn)) {
							mFriendRanking_Btn[i] = "Y";
						} else {
							mFriendRanking_Btn[i] = "";
						}
						if (x != null) {
							for (int j = 0; j < x.size(); j++) {
								if (x.get(j).equals(
										mFriendRanking.get(i).get("id"))) {
									mFriendRanking_Btn[i] = "Y";
								}
							}
						}
					}
					sImg.requestPBFriendRankingList = true;
				}
			}
			/**
			 * 실패
			 * */
			else {
				if (resultCode.equals(ErrorCode.ERR_PHONEBOOK_NO_DATA_CODE)
						|| resultCode
								.equals(ErrorCode.ERR_SERVER_USER_NOTEXIST_CODE)) { // 해당
																					// 데이터
																					// 없음
																					// //
																					// TODO
																					// 조건
																					// 추가
					/*
					 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면
					 * 됩니다.
					 */
					// Common.showToast(this,"폰북 친구 랭킹 리스트 데이타 없음" + "(" +
					// resultCode + "," + resultMsg + ")");
				} else {
					/*
					 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면
					 * 됩니다.
					 */
					// Common.showToast(this,"폰북 친구 랭킹 리스트 조회 실패" + "(" +
					// resultCode + "," + resultMsg + ")");
				}
			}
		}
		/**
		 * 게임 메시지 전송 결과 처리
		 * */
		else if (pkIndex == Packet.IF_sendGameMessageToPbFriend) {
			/**
			 * 성공
			 * */
			if (resultCode.equals(ErrorCode.SUCCESS_CODE) == true) {
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this,"게임 메시지 전송 성공");
				int hartNum = sImg.hartNum + FRIEND_GAME_SEND_COM_PEN;
				int totalNum = sImg.pointNum + sImg.currentLevel + hartNum;
				setResult(totalNum, sImg.pointNum, sImg.currentLevel, hartNum);
			}
			/**
			 * 실패
			 * */
			else {
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				if (resultCode
						.equals(ErrorCode.ERR_SERVER_SET_REJECT_MESSAGE_USER_CODE) == true) { // 게임
																								// 메시지
																								// 수신
																								// 거부
																								// 설정한
																								// 사용자
				// Common.showToast(this,"게임 메시지 수신 거부 설정한 사용자입니다." + "(" +
				// resultCode + "," + resultMsg + ")");
					sImg.message = "게임 메시지 수신 거부 설정한 사용자입니다." + "("
							+ resultCode + "," + resultMsg + ")";
				} else if (resultCode
						.equals(ErrorCode.ERR_SERVER_CAN_NOT_SEND_MESSAGE_USER_CODE) == true) { // 게임
																								// 메시지
																								// 전송
																								// 불가
																								// 사용자
				// Common.showToast(this,"게임 메시지 전송 불가한 사용자입니다." + "(" +
				// resultCode + "," + resultMsg + ")");
					sImg.message = "게임 메시지 전송 불가한 사용자입니다." + "(" + resultCode
							+ "," + resultMsg + ")";
				} else if (resultCode
						.equals(ErrorCode.ERR_SERVER_LOGOUT_USER_CODE) == true) { // 게임센터
																					// 연동
																					// 해제
																					// 사용자
				// Common.showToast(this,"게임센터 연동 해제를 한 사용자입니다." + "(" +
				// resultCode + "," + resultMsg + ")");
					sImg.message = "게임센터 연동 해제를 한 사용자입니다." + "(" + resultCode
							+ "," + resultMsg + ")";
				} else {
					// Common.showToast(this,"게임 메시지 전송 실패" + "(" + resultCode +
					// "," + resultMsg + ")");
					sImg.message = "게임 메시지 전송 실패" + "(" + resultCode + ","
							+ resultMsg + ")";
				}
				sImg.endJob = 91;
				sImg.GameMode = 98;
			}
		}

		/**
		 * 폰북 친구 초대 대상 리스트 조회 결과 처리
		 * */
		if (pkIndex == Packet.IF_getPhonebookFriendInviteList) {

			/**
			 * 성공
			 * */
			if (resp != null
					&& resultCode.equals(ErrorCode.SUCCESS_CODE) == true) { // TODO
																			// 조건
																			// 추가
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this,"폰북 초대 대상 리스트 조회 성공");

				/**
				 * 전체 항목 수 가져오기
				 * */
				int totalCnt = resp
						.getDataListSize(PacketField.IF_F_RES_LIST_FRIEND);

				if (totalCnt > 0) {
					if (mFriendInVit != null) {
						mFriendInVit.clear();
						mFriendInVit_img.clear();
					}

					/**
					 * 리스트 설정
					 * */
					for (int i = 0; i < totalCnt; i++) {
						/**
						 * 1개 정보 가져오기
						 * */
						ResponseValueDataList data = resp.getListData(i,
								PacketField.IF_F_RES_LIST_FRIEND);

						/**
						 * 정보 설정하기
						 * */
						mFriendInVit.add(getFriendInVit(data));
					}

					mFriendInVit_Btn = new String[mFriendInVit.size()];
					for (int i = 0; i < mFriendInVit.size(); i++) {
						mFriendInVit_Btn[i] = "";
					}
					sImg.DataSetFriendInVit();
				}
			}
			/**
			 * 실패
			 * */
			else {
				if (resultCode.equals(ErrorCode.ERR_PHONEBOOK_NO_DATA_CODE)
						|| resultCode
								.equals(ErrorCode.ERR_SERVER_USER_NOTEXIST_CODE)) { // 해당
																					// 데이터
																					// 없음
																					// //
																					// TODO
																					// 조건
																					// 추가
					/*
					 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면
					 * 됩니다.
					 */
					// Common.showToast(this,"폰북 초대 대상 리스트 데이타 없음" + "(" +
					// resultCode + "," + resultMsg + ")");
					sImg.message = "폰북 초대 대상 리스트 데이타 없음" + "(" + resultCode
							+ "," + resultMsg + ")";
				} else {
					/*
					 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면
					 * 됩니다.
					 */
					// Common.showToast(this,"폰북 초대 대상 리스트 조회 실패" + "(" +
					// resultCode + "," + resultMsg + ")");
					sImg.message = "폰북 초대 대상 리스트 조회 실패" + "(" + resultCode
							+ "," + resultMsg + ")";
				}
				sImg.endJob = 93;
				sImg.GameMode = 98;
			}
		}
		/**
		 * 초대 메시지 전송 결과 처리
		 * */
		else if (pkIndex == Packet.IF_sendInviteMessageToPbFriend) {
			/**
			 * 성공
			 * */
			if (resultCode.equals(ErrorCode.SUCCESS_CODE) == true) {
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this,"초대 메시지 전송 성공");
				int hartNum = sImg.hartNum + FRIEND_INVIT_SEND_COM_PEN;
				int totalNum = sImg.pointNum + sImg.currentLevel + hartNum;
				setResult(totalNum, sImg.pointNum, sImg.currentLevel, hartNum);
			}
			/**
			 * 실패
			 * */
			else {
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				if (resultCode
						.equals(ErrorCode.ERR_SERVER_EXIST_INVITATION_HISTORY_CODE) == true) { // 초대한
																								// 이력이
																								// 있는
																								// 사용자
				// Common.showToast(this,"초대한 이력이 있는 사용자입니다." + "(" + resultCode
				// + "," + resultMsg + ")");
					sImg.message = "초대한 이력이 있는 사용자입니다." + "(" + resultCode
							+ "," + resultMsg + ")";
				} else if (resultCode
						.equals(ErrorCode.ERR_SERVER_ALREADY_INVITE_CODE) == true) { // 이미
																						// 친구인
																						// 사용자
				// Common.showToast(this,"이미 친구인 사용자입니다." + "(" + resultCode +
				// "," + resultMsg + ")");
					sImg.message = "이미 친구인 사용자입니다." + "(" + resultCode + ","
							+ resultMsg + ")";
				} else if (resultCode
						.equals(ErrorCode.ERR_SERVER_SET_REJECT_INVITATION_USER_CODE) == true) { // 게임
																									// 초대
																									// 거부
																									// 설정
																									// 사용자
				// Common.showToast(this,"게임 초대 거부 설정한 사용자입니다." + "(" +
				// resultCode + "," + resultMsg + ")");
					sImg.message = "게임 초대 거부 설정한 사용자입니다." + "(" + resultCode
							+ "," + resultMsg + ")";
				} else if (resultCode
						.equals(ErrorCode.ERR_SERVER_CAN_NOT_INVITE_USER_CODE) == true) { // 초대
																							// 대상이
																							// 아닌
																							// 사용자
				// Common.showToast(this,"초대 대상이 아닌 사용자입니다." + "(" + resultCode
				// + "," + resultMsg + ")");
					sImg.message = "초대 대상이 아닌 사용자입니다." + "(" + resultCode + ","
							+ resultMsg + ")";
				} else {
					// Common.showToast(this,"초대 메시지 전송 실패" + "(" + resultCode +
					// "," + resultMsg + ")");
					sImg.message = "초대 메시지 전송 실패" + "(" + resultCode + ","
							+ resultMsg + ")";
				}
				sImg.endJob = 93;
				sImg.GameMode = 98;
			}
		}
		/**
		 * 랭킹 등록 결과 처리
		 * */
		else if (pkIndex == Packet.IF_setPoint) {
			if (resultCode.equals(ErrorCode.SUCCESS_CODE) == true) {
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this,"랭킹 등록 성공");
			} else {
				/*
				 * 샘플에서 기능 확인용이므로 실제 구현에서는 토스트 알림을 사용하지 않고 API 흐름에 맞게 적용하시면 됩니다.
				 */
				// Common.showToast(this,"랭킹 등록 실패" + "(" + resultCode + "," +
				// resultMsg + ")");
				sImg.message = "랭킹 등록 실패" + "(" + resultCode + "," + resultMsg
						+ ")";
				sImg.endJob = 96;
				sImg.GameMode = 98;
			}
		}
		return false;
	}

	/**
	 * 게임 화면 실행
	 * */
	private void invokeLoginPage(int type) {
		Log.d(LOG_TAG, "invokeGamePage()");

		APPLY_STATUS = type;
		if (APPLY_STATUS == STATUS_NO_MEMBER) {
			GameCenter.invokeTstoreJoinPage(Tifo.this);
		} else {
			sImg.GameMode = 2;
		}
	}

	/**
	 * T-store 회원가입
	 */
	public void invokeTstoreJoinPage() {
		GameCenter.invokeTstoreJoinPage(Tifo.this);
	}

	private void invokeGamePage() {
		gInfo = new GameInfo(800, 480);

		// upgradeGameCenter(); // 게임센터 DownLoad
		getSettingData(this); // 환경설정 read

		try {
			chkProcess();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		Display display = getWindowManager().getDefaultDisplay();
		Point size = new Point();

		gInfo.ScreenXsize = size.x; // super.getWindowManager().getDefaultDisplay().getWidth();
		gInfo.ScreenYsize = size.y; // super.getWindowManager().getDefaultDisplay().getHeight();
		gInfo.SetScale();

		sImg = new GameMain(this, gInfo);
		play = new GLView(this, sImg);
		play.setRenderer(new SurfaceClass(sImg));

		
		LayoutInflater inflater = this.getLayoutInflater();
		FrameLayout frameLayout = new FrameLayout(this);
		setContentView(frameLayout);

		frameLayout.addView(play);
		ad = inflater.inflate(R.layout.main, null);
		frameLayout.addView(ad);
		

		
		PBGenerateCustomNotification PBCustom = new PBGenerateCustomNotification();
		PBCustom.layout = R.layout.notification;
		PBCustom.titleId = R.id.title;
		PBCustom.messageId = R.id.message;
		PBCustom.iconId = R.id.image;
		PBCustom.icondId = R.drawable.icon_notification;
		Pushbots.getInstance().setNotificationBuilder(PBCustom);		
		
	}

	/**
	 * 게임센터 인증
	 */
	private void sucessLogin() {
		upgradeGameCenter(); // 게임센터 DownLoad
		// sImg.GameMode = 2;
		getServer();
	}

	// //////////////////////////////////////////////////////////
	// //////////////////////////////////////////////////////////
	// ////////////////// 서버 //////////////////////////////////
	// //////////////////////////////////////////////////////////

	public boolean getDataChk() {
		boolean chk = false;
		if (defaultSharedPref.getString("data_chk", "").equals("")) {
			chk = false;
		} else {
			chk = true;
		}
		return chk;
	}

	public void setDataChk() {
		SharedPreferences.Editor editor01 = defaultSharedPref.edit();
		editor01.putString("data_chk", "Y");
		editor01.commit();

		sImg.GameMode = 88;
	}

	/**
	 * 인증이 되지 않을때 다시 인증하는 로직
	 */
	private void reLogin() {
		// ///////////////////////////
		// / 1) 인증 사용자정보 등록
		// ///////////////////////////
		upgradeGameCenter(); // 게임센터 DownLoad

		System.out.println("reLogin --------------------");
		System.out.println(mUserData.nickName);
		String name = " ";
		if (mUserData.name != null)
			name = mUserData.name;
		System.out.println(name);
		System.out.println(mUserData.mdn);

		ArrayList<HashMap<String, String>> params = new ArrayList<HashMap<String, String>>();
		HashMap map = new HashMap();
		map.put("paramJ", "MEM_INSERT");
		map.put("USER_ID", Util.encodeSTR(mUserData.nickName));
		map.put("USER_NAME", name);
		map.put("USER_NICKNAME", mUserData.nickName);
		map.put("USER_HP", Util.encodeSTR(mUserData.mdn));
		map.put("USER_TIME", "2");
		map.put("TIFO_COUNT", bas_tifoCount + "");
		map.put("JOB_TYPE", "1");
		params.add(map);
		System.out.println("reLogin -------------end ");

		// getNotice();
		mAsynInfo = new AsyncInfo();
		mAsynInfo.execute(params);

	}

	/**
	 * 공지사항 읽기
	 */
	public void getNotice() {
		mTaskInfo = new loadImageAsync();
		mTaskInfo.execute(SERVER_WEB + "notice.png", "3");

		requestPBFriendRankingList(); // 친구순위

		// ///////////////////////////
		// / 3) 공지사항
		// ///////////////////////////
		ArrayList<HashMap<String, String>> params = new ArrayList<HashMap<String, String>>();
		HashMap map = new HashMap();
		map.put("paramJ", "NOTICE_VIEW");
		map.put("JOB_TYPE", "3");
		params.add(map);

		// ArrayList<HashMap<String, String>> result = getService(params);
		// if(result.get(0).get("notice").equals("Y")) {
		// sImg.GameMode = 90; // 공지사항
		// } else {
		// sImg.GameMode = 91; //
		// sImg.LoadWeekRanking(); // 친구순위 Sprite Load
		// }

		AsyncInfo mAsynInfo = new AsyncInfo();
		mAsynInfo.execute(params);
	}

	/**
	 * 서버 호출
	 */
	private void getServer() {
		// ///////////////////////////
		// / 2) 로그인
		// ///////////////////////////
		ArrayList<HashMap<String, String>> params = new ArrayList<HashMap<String, String>>();
		HashMap map = new HashMap();
		map.put("paramJ", "MEM_VIEW");
		map.put("USER_ID", Util.encodeSTR(mUserData.nickName));
		map.put("JOB_TYPE", "2");
		params.add(map);

		AsyncInfo mAsynInfo = new AsyncInfo();
		mAsynInfo.execute(params);
	}

	private void setStageButton() {
		for (int i = 0; i <= sImg.currentLevel; i++)
			sImg.StageData[i] = 1; // 스테이지 데이터 초기화

		sImg.LoadStageButton();
	}

	/**
	 * 레벨
	 * 
	 * @param level
	 */
	public void setLevel(int level) {
		sImg.currentLevel = level;
		setStageButton();
	}

	/*
	 * 점수를 등록한다
	 */
	public void setResult(int totalNum, int pointNum, int currentLevel,
			int hartNum) {
		// ///////////////////////////
		// / 4) 점수등록
		// ///////////////////////////
		ArrayList<HashMap<String, String>> params = new ArrayList<HashMap<String, String>>();
		HashMap map = new HashMap();
		map.put("paramJ", "POINT_VIEW");
		map.put("USER_ID", Util.encodeSTR(mUserData.nickName));
		map.put("TOTAL_NUM", totalNum + "");
		map.put("GAME_NUM", pointNum + "");
		map.put("HART_NUM", hartNum + "");
		map.put("STAGE", currentLevel + "");
		map.put("TIFO_COUNT", bas_tifoCount + "");
		map.put("JOB_TYPE", "4");
		params.add(map);
		AsyncInfo mAsynInfo = new AsyncInfo();
		mAsynInfo.execute(params);

		// / 서버 등록 ///
		// setPoint(totalNum+"");
		// sImg.currentLevel = currentLevel;
		// sImg.pointNum = pointNum;
		// sImg.hartNum = hartNum;
		//
		// sImg.pre_pointNum = sImg.pointNum;
		// sImg.pre_hartNum = sImg.hartNum;
	}

	/*
	 * 하트 점수를 서버에 저장 hart 차감된 값 tifoCount 티포의 갯수 hart1 소모된 값
	 */
	public void setTifoBuy(int hartNum, int tifoCount, int hartNum1) {
		// ///////////////////////////
		// / 5) 사이버머니 이력등록
		// ///////////////////////////
		ArrayList<HashMap<String, String>> params = new ArrayList<HashMap<String, String>>();
		HashMap map = new HashMap();
		map.put("paramJ", "HART_INSERT");
		map.put("USER_ID", Util.encodeSTR(mUserData.nickName));
		map.put("HART_NUM", hartNum + "");
		map.put("HART_NUM1", hartNum1 + "");
		map.put("TIFO_COUNT", tifoCount + "");
		map.put("JOB_TYPE", "5");
		params.add(map);
		AsyncInfo mAsynInfo = new AsyncInfo();
		mAsynInfo.execute(params);

	}

	/**
	 * 게임 시간을 수정
	 * 
	 * @param time
	 */
	private void setGameTime(int time, String pid, String resultCode,
			String resultMessage) {
		// ///////////////////////////
		// / 6) 아이템 구매 이력등록
		// ///////////////////////////
		int amount = 0;
		if (pid.equals(PID_1)) {
			amount = 1000;
		} else if (pid.equals(PID_2)) {
			amount = 2000;
		} else if (pid.equals(PID_3)) {
			amount = 3000;
		} else if (pid.equals(PID_4)) {
			amount = 4000;
		} else if (pid.equals(PID_5)) {
			amount = 5000;
		} else if (pid.equals(PID_6)) {
			amount = 6000;
		}

		ArrayList<HashMap<String, String>> params = new ArrayList<HashMap<String, String>>();
		HashMap map = new HashMap();
		map.put("paramJ", "PURCHASE_INSERT");
		map.put("USER_ID", Util.encodeSTR(mUserData.nickName));
		map.put("ITEM_NO", pid);
		map.put("PAY_AMOUNT", amount + "");
		if (resultCode.equals("0000")) {
			map.put("PAY_SUCCESS", "Y");
			map.put("ERRO_CODE", "");
		} else {
			map.put("PAY_SUCCESS", "N");
			map.put("ERRO_CODE", resultMessage);
		}
		map.put("JOB_TYPE", "6");
		map.put("USER_TIME", sImg.timeCount + time + "");
		params.add(map);
		AsyncInfo mAsynInfo = new AsyncInfo();
		mAsynInfo.execute(params);

	}

	public ArrayList<HashMap<String, String>> getVersion() {
		Log.i("aaa", "curVersion = " + curVersion);

		ArrayList<HashMap<String, String>> params = new ArrayList<HashMap<String, String>>();
		HashMap map = new HashMap();
		map.put("paramJ", "VERSION");
		map.put("JOB_TYPE", "7");
		params.add(map);

		return params;

	}

	public void callTStore() {
		 sImg.Back_Music.stop();
		 finish();
//		 Intent intent1 = new Intent(this, WebViewActivity.class);
//		 intent1.putExtra("URL", "http://m.tstore.co.kr/mobilepoc/apps/appsDetail.omp?prodId=0000651516");
//		 startActivity(intent1);
		 
		 
		 Intent intent = new Intent();

	     intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);

		 intent.setClassName("com.skt.skaf.A000Z00040", "com.skt.skaf.A000Z00040.A000Z00040");

		 intent.setAction("COLLAB_ACTION");

		 intent.putExtra("com.skt.skaf.COL.URI", "PRODUCT_VIEW/0000651516/0".getBytes());  
		 intent.putExtra("com.skt.skaf.COL.REQUESTER", "A000Z00040") ;
		 startActivity(intent);
	}

	Handler mHandler = new Handler() {
		public void handleMessage(Message msg) {
			if (((String) msg.obj).equals("7")) { // VERSION
				ArrayList<HashMap<String, String>> params = getVersion();
				mAsynInfo = new AsyncInfo();
				mAsynInfo.execute(params);

			}
		}
	};

	//
	private class AsyncInfo
			extends
			AsyncTask<ArrayList<HashMap<String, String>>, Void, ArrayList<HashMap<String, String>>> {

		String jobType = "";
		ArrayList<HashMap<String, String>> param;

		@Override
		protected ArrayList<HashMap<String, String>> doInBackground(
				ArrayList<HashMap<String, String>>... params) {
			// 백그라운드 스레드에서 처리해야 할 작업은 여기에 지정한다
			ArrayList<HashMap<String, String>> ret = null;
			try {
				jobType = params[0].get(0).get("JOB_TYPE");
				param = params[0];
				ret = getService(params[0]);
			} catch (Exception e) {
				Log.d("MapError", e.toString());
			}
			return ret;
		}

		@Override
		protected void onPostExecute(ArrayList<HashMap<String, String>> result) {
			// 백그라운드 작업이 종료된 직후에 화면에 처리해야 할 작업은 여기에 지정한다
			System.out.println("----------- " + result.get(0).get("ERR_CODE")
					+ result.get(0).get("ERR_MSG"));
			if (null == result || result.get(0).get("ERR_CODE").equals("900")) {
				sImg.message = "게임서버가 점검중입니다. 잠시후 다시 하세요("
						+ result.get(0).get("ERR_MSG") + ")";
				sImg.endJob = 99;
				sImg.GameMode = 98;
			} else {
				if (jobType.equals("1")) {
					// getNotice(); // 공지사항
					sImg.currentLevel = 0; // stage num
					sImg.tifoCount = Integer.parseInt(param.get(0).get(
							"TIFO_COUNT")); // 티포의 갯수
					sImg.timeCount = Integer.parseInt(param.get(0).get(
							"USER_TIME")); // 구매한 타임의 수
					sImg.pointNum = 0; // 게임 점수
					sImg.hartNum = 0; // 하트 점수

					sImg.pre_pointNum = sImg.pointNum;
					sImg.pre_hartNum = sImg.hartNum;

					sImg.outtime = sImg.timeCount * 60;

					setStageButton();
					sImg.GameMode = 85;
				}
				if (jobType.equals("2")) {
					if (result.get(0).get("ERR_CODE").equals("OK")) {
						sImg.currentLevel = Integer.parseInt(result.get(0).get(
								"STAGE")); // stage num
						sImg.tifoCount = Integer.parseInt(result.get(0).get(
								"TIFO_COUNT")); // 티포의 갯수
						sImg.timeCount = Integer.parseInt(result.get(0).get(
								"USER_TIME")); // 구매한 타임의 수
						sImg.pointNum = Integer.parseInt(result.get(0).get(
								"GAME_NUM")); // 게임 점수
						sImg.hartNum = Integer.parseInt(result.get(0).get(
								"HART_NUM")); // 하트 점수

						sImg.pre_pointNum = sImg.pointNum;
						sImg.pre_hartNum = sImg.hartNum;

						sImg.outtime = sImg.timeCount * 60;

						setStageButton();
						sImg.GameMode = 2;

						// sImg.currentLevel = 30; // stage num
						// sImg.tifoCount = 5; // 티포의 갯수
						// sImg.timeCount = 2; // 구매한 타임의 수
						// sImg.pointNum = 100; // 게임 점수
						// sImg.hartNum = 50; // 하트 점수
						//
						// sImg.pre_pointNum = sImg.pointNum;
						// sImg.pre_hartNum = sImg.hartNum;
						//
						// sImg.outtime = sImg.timeCount * 60;
						//
						// setStageButton();
					} else if (result.get(0).get("ERR_CODE").equals("NO")) {

						sImg.GameMode = 2;
						reLogin();
					}
				}
				if (jobType.equals("3")
						&& result.get(0).get("ERR_CODE").equals("OK")) {
					if (result.get(0).get("notice").equals("Y")) {
						sImg.GameMode = 90; // 공지사항
					} else {
						// sImg.LoadWeekRanking();
						sImg.GameMode = 91;
					}
				}
				if (jobType.equals("4")
						&& result.get(0).get("ERR_CODE").equals("OK")) {
					setPoint(param.get(0).get("TOTAL_NUM"));
					sImg.currentLevel = Integer.parseInt(param.get(0).get(
							"STAGE"));
					sImg.pointNum = Integer.parseInt(param.get(0).get(
							"GAME_NUM"));
					sImg.hartNum = Integer.parseInt(param.get(0)
							.get("HART_NUM"));

					sImg.pre_pointNum = sImg.pointNum;
					sImg.pre_hartNum = sImg.hartNum;
				}
				if (jobType.equals("5")
						&& result.get(0).get("ERR_CODE").equals("OK")) {
					sImg.hartNum = Integer.parseInt(param.get(0)
							.get("HART_NUM"));
					sImg.pre_hartNum = Integer.parseInt(param.get(0).get(
							"HART_NUM"));

					sImg.tifoCount = Integer.parseInt(param.get(0).get(
							"TIFO_COUNT"));

					sImg.GameMode = 91;
				}
				if (jobType.equals("6")
						&& result.get(0).get("ERR_CODE").equals("OK")) {
					sImg.timeCount = Integer.parseInt(param.get(0).get(
							"USER_TIME"));
					sImg.outtime = sImg.timeCount * 60;
					sImg.GameMode = 91;
				}
				if (jobType.equals("7")) {
					if(result.get(0).get("ERR_CODE").equals("OK")) {
						if (!result.get(0).get("VERSION").equals(curVersion)) {
							sImg.message = "버전이 업데이트 되었습니다. 새로운 버전을 받으세요";
							sImg.endJob = 87;
							sImg.GameMode = 98;
						}
					} else {
						sImg.message = result.get(0).get("ERR_MSG");
						sImg.endJob = 99;
						sImg.GameMode = 98;
					}
				}

			}
			super.onPostExecute(result);
		}

		@Override
		protected void onPreExecute() {
			// 작업이 시작되기 직전에 화면에 처리해야 할 작업은 여기에 지정한다
			super.onPreExecute();
		}
	}

	/**
	 * 서비스 조회
	 */
	private ArrayList<HashMap<String, String>> getService(
			ArrayList<HashMap<String, String>> params) {
		DataCommunication dbComm = new DataCommunication();
		ArrayList<HashMap<String, String>> list = dbComm.sendData(SERVER_URL,
				params);
		return list;
	}

	public void uploadLocationToServerThroughAsyncTask(Location loc) {
		// TODO Auto-generated method stub

	}

	// ///////////////////////////////////////////////////////
	// ///////////////////////////////////////////////////////

	/**
	 * T store 인증 요청
	 * */
	private void requestReTstoreAuth() {
		Log.d(LOG_TAG, "requestTstoreAuth()");

		try {
			bAuthTstore = true;
			mGCAPIManager.authTstore(this);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 게임센터 연동 요청
	 * */
	public void requestEnableConnection() {
		Log.d(LOG_TAG, "requestEnableConnection()");

		try {
			mGCAPIManager.enableGameCenterConnection(this, GCID);

		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 폰북 친구 랭킹 리스트 요청
	 * */
	public void requestPBFriendRankingList() {
		Log.d(LOG_TAG, "requestPBFriendRankingList()");

		try {
			mGCAPIManager.getPhonebookFriendRankList(this, GCID);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 랭킹 리스트 항목 설정
	 * */
	private HashMap getFriendRanking(final ResponseValueDataList data) {
		/**
		 * 랭킹 정보 가져오기
		 * */
		String name = data.getResponseValue(PacketField.IF_F_RES_FRIEND_NAME); /* 이름 */
		final String mdn = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_MDN); /* MDN */
		final String id = data.getResponseValue(PacketField.IF_F_RES_FRIEND_ID); /* 아이디 */
		String imageUrl = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_IMAGE_URL); /*
																		 * 이미지
																		 * URL
																		 */
		String messageYn = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_MESSAGE_YN); /*
																			 * 메시지
																			 * 수신
																			 * 여부
																			 */
		String point = data.getResponseValue(PacketField.IF_F_RES_FRIEND_POINT); /*
																				 * 랭킹
																				 * 점수
																				 */
		String ranking = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_RANK) + "위"; /* 랭킹 */
		String isMine = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_IS_MINE); /*
																		 * 내 순위
																		 * 여부
																		 */
		if (point == null)
			point = "0 점";

		HashMap map = new HashMap();
		map.put("name", name);
		map.put("mdn", mdn);
		map.put("id", id);
		map.put("imageUrl", imageUrl);
		map.put("messageYn", messageYn);
		map.put("point", point);
		map.put("ranking", ranking);
		map.put("isMine", isMine);
		mTaskInfo = new loadImageAsync();
		mTaskInfo.execute(imageUrl, "1");
		return map;
	}

	/**
	 * 리스트 항목 설정
	 * */
	private HashMap getFriendInVit(final ResponseValueDataList data) {

		String name = data.getResponseValue(PacketField.IF_F_RES_FRIEND_NAME); /* 이름 */
		final String mdn = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_MDN); /* MDN */
		final String id = data.getResponseValue(PacketField.IF_F_RES_FRIEND_ID); /* 아이디 */
		String imageUrl = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_IMAGE_URL); /*
																		 * 이미지
																		 * URL
																		 */
		String Invitation = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_INVITATION_YN); /*
																			 * 초대
																			 * 설정
																			 * 상태
																			 */
		String invited = data
				.getResponseValue(PacketField.IF_F_RES_FRIEND_INVITED_YN); /*
																			 * 초대
																			 * 상태
																			 */

		HashMap map = new HashMap();
		map.put("name", name);
		map.put("mdn", mdn);
		map.put("id", id);
		map.put("imageUrl", imageUrl);
		map.put("Invitation", Invitation);
		map.put("invited", invited);
		// if(imageUrl == null) {
		// mFriendInVit_img.add(null);
		// } else {
		// mTaskInfo = new loadImageAsync();
		// mTaskInfo.execute(imageUrl, "2");
		// }
		mFriendInVit_img.add(null);

		return map;
	}

	/**
	 * 폰북 친구 초대 대상 리스트 요청
	 * */
	public void requestPBInviteTargetList() {
		Log.d(LOG_TAG, "requestPBInviteTargetList()");

		try {
			mGCAPIManager.getPhonebookFriendInviteList(this, GCID);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
	}

	/*
	 * 게임센터 다운로드 팝업 리스너
	 */
	private DialogInterface.OnClickListener mDownloandGameCenterListener = new DialogInterface.OnClickListener() {
		@Override
		public void onClick(DialogInterface dialog, int which) {

			int result = GameCenter.checkInstalledTstorePackage();
			if (result == GameCenter.RESULT_TSTORE_NOT_INSTALLED) {
				/* T store 다운로드 확인 팝업 */
				AlertDialog dlg = new AlertDialog.Builder(Tifo.this)
						.setTitle("안내")
						.setMessage(
								"T store 게임센터가 업그레이드를 위하여 T store 설치가 필요합니다.\nT store를 설치하시겠습니까?\nT store 설치 후 게임센터를 다시 실행해 주십시오.")
						.setPositiveButton("예", mDownloandTstoreListener)
						.setNegativeButton("아니오", null).create();
				dlg.show();
			} else {
				GameCenter.invokeGameCenterDownload();
			}
		}
	};
	/*
	 * T store 다운로드 팝업 리스너
	 */
	private DialogInterface.OnClickListener mDownloandTstoreListener = new DialogInterface.OnClickListener() {
		@Override
		public void onClick(DialogInterface dialog, int which) {
			GameCenter.invokeTstoreDownload(Tifo.this);
		}
	};

	/**
	 * 이미지를 가져오는 메소드
	 * 
	 * @author jxkks
	 * 
	 */
	public class loadImageAsync extends AsyncTask<String, Void, Void> {
		String img_type = "";

		@Override
		protected Void doInBackground(String... params) {
			if (params[0] == null) {
				myProfileBm = null;
			} else {
				img_type = params[1];
				myProfileBm = getBitmapFromURL(params[0]);
			}
			return null;
		}

		@Override
		protected void onPostExecute(Void result) {
			System.out.println(" IMG ===> " + img_type + " >>> "
					+ FRIEND_RANKING);
			if (img_type.equals(FRIEND_RANKING)) {
				mFriendRanking_img.add(myProfileBm);
				System.out.println(1);
			} else if (img_type.equals(FRIEND_INVIT)) {
				mFriendInVit_img.add(myProfileBm);
			} else if (img_type.equals(NOTICE_IMG)) {
				noticeBm = myProfileBm;
			}
			Log.i("TAG", "onPostExecute::");
			super.onPostExecute(result);
		}
	}

	/**
	 * 친구랭킹 메소드 보내기
	 * 
	 * @param id
	 * @param mdn
	 */
	public void sendGameMessageToPbFriend(String id, String mdn, String point) {
		try {
			/**
			 * 게임 메시지 설정
			 * */
			String msg = "게임 랭킹 " + point;

			/**
			 * 메시지에 링크 포함 여부 설정
			 * */
			String linkYn = "Y";
			mGCAPIManager.sendGameMessageToPbFriend(this, GCID, id, msg, mdn,
					linkYn); // TODO 친구 통신사 삭제
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
	}

	public void sendInviteMessageToPbFriend(String id, String mdn) {
		try {
			mGCAPIManager.sendInviteMessageToPbFriend(this, GCID, id, mdn); // TODO
																			// 통신사
																			// 삭제
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}

	}

	/**
	 * 체크 로직
	 * 
	 * @throws Exception
	 */
	public void chkProcess() throws Exception {
		ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo ni = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
		boolean isWifiAvail = ni.isAvailable();
		isWifiConn = ni.isConnected();
		ni = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
		boolean isMobileAvail = ni.isAvailable();
		isMobileConn = ni.isConnected();

		String status = "WiFi\nAvail = " + isWifiAvail + "\nConn = "
				+ isWifiConn + "\nMobile\nAvail = " + isMobileAvail
				+ "\nConn = " + isMobileConn + "\n";
	}

	/**
	 * 랭킹등록
	 * 
	 * @param point
	 */
	private void setPoint(String point) {
		String displayPoint = point + "point";

		try {
			mGCAPIManager.setPoint(this, GCID, LEADER_BOARD_ID, point,
					displayPoint);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 보상정핵에 대한 제한 (친구행킹에서 메세지를 하루한번)
	 * 
	 * @param id
	 */
	public void setCompen(Context context, String id, String mdn, String ranking) {
		String res = "";

		String date = Util.getDateNoFormat(Util.getCurrentDate());
		System.out.println("오늘  = " + date);
		try {

			String res2 = mComPenData.getData(context, date, id);
			System.out.println("res2 = " + res2);

			if (res2.equals("NO")) {
				// mComPenData.prcs(this.context, "I", date, id);
			} else {
				res = "OK";
			}

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		if (mUserData.mdn.equals(mdn)) {
			sImg.message = "자신에게는 메세지를 보낼수 없습니다.";
			sImg.endJob = 91;
			sImg.GameMode = 98;
		} else if (res.equals("OK")) {
			sImg.message = "오늘 메세지를 이미 보냈습니다.";
			sImg.endJob = 91;
			sImg.GameMode = 98;
		} else {
			sendGameMessageToPbFriend(id, mdn, ranking);
		}
	}

	// /////////////////////////////////////////////////////////////////////////////////
	// ///////////////////// 결제
	// /////////////////////////////////////////////////////
	// /////////////////////////////////////////////////////////////////////////////////
	String receipt = "";
	String txid = "";
	String resultCode = "";
	String resultMessage = "";

	public void callPayment(String pid) {
		int time = 0;
		if (pid.equals(PID_1)) {
			time = 1;
		} else if (pid.equals(PID_2)) {
			time = 2;
		} else if (pid.equals(PID_3)) {
			time = 3;
		} else if (pid.equals(PID_4)) {
			time = 4;
		} else if (pid.equals(PID_5)) {
			time = 5;
		} else if (pid.equals(PID_6)) {
			time = 6;
		}

		if (requestPayment(pid, time)) {
		} else {
			sImg.message = resultMessage;
			sImg.endJob = 94;
			sImg.GameMode = 98;
		}

	}

	private Handler mUiHandler = new Handler() {

		@Override
		public void handleMessage(Message msg) {
			if (msg.what == 100) {
				// Common.showToast(Tifo.this,(String) msg.obj);
			} else if (msg.what == 101) {
				final Response response = (Response) msg.obj;
				JSONObject json = new JSONObject();
				try {
					json.put("appid", AID);
					json.put("txid", response.result.txid);
					Log.d("Receipt", response.result.receipt.length()
							+ " is the receipt ");
					json.put("signdata", response.result.receipt);
				} catch (JSONException e) {
					e.printStackTrace();
					Common.showToast(Tifo.this,
							"Failed while composing json data for verification receipt.");
				}

				ReceiptConfirm rc = new ReceiptConfirm();
				rc.execute((String) json.toString());
			} else if (msg.what == 200) {
				Common.showToast(Tifo.this, (String) msg.obj);
			}
		}
	};

	private String makeRequest(String pid) {
		ParamsBuilder pb = new ParamsBuilder();

		pb.put(ParamsBuilder.KEY_APPID, AID).put(ParamsBuilder.KEY_PID, pid);

		String tmp = "";
		if (!TextUtils.isEmpty(tmp)) {
			pb.put(ParamsBuilder.KEY_PNAME, tmp);
		} else {
			pb.put(ParamsBuilder.KEY_PNAME, "");
		}

		tmp = "";
		if (!TextUtils.isEmpty(tmp)) {
			pb.put(ParamsBuilder.KEY_TID, tmp);
		} else {
			pb.put(ParamsBuilder.KEY_TID, "");
		}

		tmp = "";
		if (!TextUtils.isEmpty(tmp)) {
			pb.put(ParamsBuilder.KEY_BPINFO, tmp);
		} else {
			pb.put(ParamsBuilder.KEY_BPINFO, tmp);
		}

		return pb.build();
	}

	private boolean requestPayment(final String pid, final int time) {
		String parameter = makeRequest(pid);
		mUiHandler.obtainMessage(100, parameter).sendToTarget();
		Bundle req = mPlugin.sendPaymentRequest(parameter,
				new IapPlugin.RequestCallback() {

					@Override
					public void onResponse(IapResponse data) {
						if (data == null || data.getContentLength() <= 0) {
							// TODO Unusual error
							mUiHandler.obtainMessage(100,
									"onResponse() response data is null")
									.sendToTarget();
							return;
						}

						// 1. JSON 데이터를 통한 객체 변환 사용 예
						Response response = ConverterFactory.getConverter()
								.fromJson(data.getContentToString());

						if (response == null) {
							// TODO invalid response data
							mUiHandler.obtainMessage(100,
									"onResponse() invalid response data")
									.sendToTarget();
							return;
						}

						// TODO for logging
						StringBuffer sb = new StringBuffer("onResponse() \n");
						sb.append("From:" + data.getContentToString())
								.append("\n")
								.append("To:" + response.toString());
						mUiHandler.obtainMessage(100, sb.toString())
								.sendToTarget();

						// TODO 구매 완료 후 처리 예 - 성공
						// C1. 결과 코드 체크
						// response.result.code
						if (!response.result.code.equals("0000")) {
							resultCode = response.result.code;
							resultMessage = "Failed to request to purchase a item";
							mUiHandler.obtainMessage(200,
									"Failed to request to purchase a item")
									.sendToTarget();

							sImg.message = resultMessage;
							sImg.endJob = 94;
							sImg.GameMode = 98;
							return;
						}

						// S1. 구매 완료의 경우 발급된 전자 영수증을 통한 구매 확인 체크 (강력 권고)
						// response.result.txid
						// response.result.receipt
						mUiHandler.obtainMessage(101, response).sendToTarget();

						// S2. 구매 상품 타입에 따른 상품 발급 처리
						// 아이템 발그 / 정식판 전환

						// TODO 구미 완료 후 처리 예- 실패
						// C1. 결과 코드 체크
						// response.result.code

						// F1. 결과 코드가 긴급 공지인 경우 사용자가 인지할 수 있는 방법으로 알림 (팝업 창 등)

						// 2. JSON 데이터 그대로 사용 예

						// TODO 구매 완료 후 처리 예 - 성공 / 실패

						// C1. 결과 코드 체크
						try {
							JSONObject jsonMain = new JSONObject(data
									.getContentToString());
							JSONObject jsonResult = jsonMain
									.getJSONObject("result");
							String code = jsonResult.getString("code");
							String message = jsonResult.getString("message");
							if (code.equals("0000")) {

								// S1. 구매 완료의 경우 발급된 전자 영수증을 통한 구매 확인 체크 (강력 권고)
								receipt = jsonResult.getString("receipt");
								txid = jsonResult.getString("txid");

								// S2. 구매 상품 타입에 따른 상품 발급 처리 // 아이템 발그 / 정식판 전환
								resultCode = code;
								resultMessage = "정상적으로 처리 되었습니다.";

								setGameTime(time, pid, resultCode,
										resultMessage);
								sImg.message = resultMessage;
								sImg.endJob = 91;
								sImg.GameMode = 98;
								Common.showToast(Tifo.this, "정상적으로 처리 되었습니다.");
							} else {
								// F1. 결과 코드가 긴급 공지인 경우 사용자가 인지할 수 있는 방법으로 알림
								// (팝업 창 등)
								resultCode = code;
								resultMessage = message;

								sImg.message = resultMessage;
								sImg.endJob = 94;
								sImg.GameMode = 98;
								Common.showToast(Tifo.this, "비정상적으로 처리 되었습니다.");
							}
						} catch (JSONException e) {
							e.printStackTrace();
						}

					}

					@Override
					public void onError(String reqid, String errcode,
							String errmsg) {
						// TODO Error occurred
						mUiHandler.obtainMessage(
								100,
								"onError() identifier:" + reqid + " code:"
										+ errcode + " msg:" + errmsg)
								.sendToTarget();
					}
				});

		// if (req == null) {
		// // TODO request failure
		// return false;
		// }

		// mRequestId = req.getString(IapPlugin.EXTRA_REQUEST_ID);
		// if (mRequestId == null || mRequestId.length() == 0) {
		// // TODO request failure
		// return false;
		// }

		return true;
	}

	private class ReceiptConfirm extends AsyncTask<String, Void, String> {
		final String convertStreamToString(InputStream is) throws IOException {
			ByteArrayOutputStream bs = new ByteArrayOutputStream();
			int i = is.read();
			while (i != -1) {
				bs.write(i);
				i = is.read();
			}
			return bs.toString();
		}

		@Override
		protected void onPostExecute(String result) {
			// TODO
			if (TextUtils.isEmpty(result)) {
				Common.showToast(Tifo.this,
						"Failed to request to verify receipt.");
			} else {
				VerifyReceipt r = ConverterFactory.getConverter()
						.fromJson2VerifyReceipt(result);
				// Common.showToast(Tifo.this, r.toString());
			}
		}

		@Override
		protected String doInBackground(String... params) {
			HttpClient client = new DefaultHttpClient();
			// String DEV_SERVER_URL =
			// "https://iapdev.tstore.co.kr/digitalsignconfirm.iap";
			HttpPost httpPostRequest = new HttpPost(REAL_SERVER_URL);
			StringEntity se;
			try {
				se = new StringEntity(params[0], "UTF-8");
				httpPostRequest.setEntity(se);
				httpPostRequest.setHeader("Content-type", "application/json");
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
			try {
				HttpResponse resp = client.execute(httpPostRequest);
				if (resp.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
					HttpEntity respEntity = resp.getEntity();
					if (respEntity != null) {
						try {
							InputStream ins = respEntity.getContent();
							return convertStreamToString(ins);
						} catch (IllegalStateException e) {
							e.printStackTrace();
						} catch (IOException e) {
							e.printStackTrace();
						}

					}
				}
			} catch (ClientProtocolException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return null;
		}
	}

	public class mPhoneStateListener extends PhoneStateListener {
		@Override
		public void onCallStateChanged(int state, String incomingNumber) {
			if (state == TelephonyManager.CALL_STATE_RINGING) {
				if (sImg != null)
					sImg.Back_Music.pause();
			} else if (state == TelephonyManager.CALL_STATE_IDLE) {
				if (sImg != null) {
					if(back_sound.equals("Y")) {
						sImg.Back_Music.start();
					}
				}
					
			}
		}
	}
}